package persistent.impl;

import java.util.ArrayList;
import java.util.List;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.Session;
import org.hibernate.Transaction;

import basic.HibBaseDAO;
import basic.HibernateSessionFactory;
import model.TDimensionOption;
import model.TOption;
import model.TTitle;
import model.TitleBatch;
import model.VTitle;
import persistent.dao.ITitleDAO;
import persistent.factory.DAOFactory;
import util.toolkit.Constant;
import util.toolkit.Expression;
import util.toolkit.GenerateUUID;
import util.toolkit.LogUtil;
import util.toolkit.StringArraySort;

/**
 * 题目信息处理业务接口实现
 * @author 徐震霖
 * @since 2019-02-21
 */
public class TitleImpl implements ITitleDAO {

	private HibBaseDAO dao = null;
	private static final Log log = LogFactory.getLog(HibBaseDAO.class);

	public TitleImpl() {
		dao = new HibBaseDAO();
	}

	/**
	 * 添加一个题目信息（添加题目信息的同时要添加选项信息）
	 * @param title 题目信息对象
	 * @param options 选项信息对象列表
	 * @return 成功返回true，失败返回false
	 */
	//旧的题目选项一起添加的
//	@Override
//	public boolean addTitle(TTitle title, List<TOption> options) {
//
//		GenerateUUID UUID = new GenerateUUID();
//
//		Session session = HibernateSessionFactory.getSession();
//		Transaction tx = null;
//		try {
//			tx = session.beginTransaction();
//			String titleid = UUID.getUUID();
//			System.out.println(titleid);
//			title.setTitleid(titleid);
//			session.save(title);
//			for (TOption tOption : options) {
//				tOption.setTitleid(titleid);
//				tOption.setTitleid(title.getTitleid());
//				session.save(tOption);
//			}
//			tx.commit();
//			session.close(); // 关闭连接
//			return true;
//		} catch (Exception e) {
//			if (tx != null)
//				tx.rollback();
//			session.close(); // 关闭连接
//			log.error("persistent.impl.TitleImpl类的addTitle(TTitle title, List<TOption> options)方法调用错误：");
//			log.error(LogUtil.getMsg(e));
//			System.out.println("persistent.impl.TitleImpl类的addTitle(TTitle title, List<TOption> options)方法调用错误：");
//			e.printStackTrace();
//		}
//		return false;
//	}

	/**
	 * 添加一个选项信息（用于编辑是添加某题选项不够的情况）
	 * @param option 选项信息对象
	 * @return 成功返回true，失败返回false
	 */
	@Override
	public boolean addOption(TOption option) {	
		
		Session session = HibernateSessionFactory.getSession();
		Transaction tx = null;
		try {
			tx = session.beginTransaction();
			
			TTitle title = (TTitle) dao.findById(TTitle.class, option.getTitleid());
			
			
			if(title.getOptionNumber() != null){
				title.setOptionNumber(title.getOptionNumber() + 1);
			}
			else{
				title.setOptionNumber(1);
			}
			//TODO 2019-02-25 16:43 徐震霖修改开始
			if (title.getOptionContent() != null && !title.getOptionContent().equals("")) {
				String optonCon = title.getOptionContent() + option.getOptionContent() + Constant.STRING_SPLIT;
				String[] optionCons = optonCon.split(Constant.STRING_SPLIT);
				String[] sortOptionCons = StringArraySort.arraySort(optionCons);
				String sortOptionCon = "";
				for(int i = 0; i < sortOptionCons.length; i++){
					sortOptionCon += sortOptionCons[i] + Constant.STRING_SPLIT;
				}
				//System.out.println(sortOptionCon);
				title.setOptionContent(sortOptionCon);
			}
			else {
				String optonCon = option.getOptionContent() + Constant.STRING_SPLIT;
				title.setOptionContent(optonCon);
			}
			//TODO 2019-02-25 16:43 徐震霖修改结束
			GenerateUUID uuid = new GenerateUUID();
			option.setOptionid(uuid.getUUID());
			session.update(title);
			session.save(option);
			tx.commit();
			session.close(); // 关闭连接
			return true;
		}
		catch (Exception e) {
			if (tx != null) tx.rollback();
			session.close(); // 关闭连接
			log.error("persistent.impl.TitleImpl类的addTitle(TTitle title)方法调用错误：");
			log.error(LogUtil.getMsg(e));
			System.out.println("persistent.impl.TitleImpl类的addTitle(TTitle title)方法调用错误：");
			e.printStackTrace();
		}
		return false;
		
	}

	/**
	 * 修改一个题目信息
	 * @param title 题目信息对象
	 * @return 成功返回true，失败返回false
	 */
	@Override
	public boolean updateTitle(TTitle title) {
		return dao.update(title);
	}

	/**
	 * 修改一个题目选项信息
	 * @param option 题目选项信息对象
	 * @return 成功返回true，失败返回false
	 */
	@Override
	public boolean updateOption(TOption option) {
		return dao.update(option);
	}

	/**
	 * 删除一个题目信息（删除题目信息时要先删除题目对应选项信息）
	 * @param title 题目信息编号
	 * @return 成功返回true，失败返回false
	 */
	@Override
	public boolean deleteTitle(String titleid) {

		Session session = HibernateSessionFactory.getSession();
		Transaction tx = null;
		try {
			tx = session.beginTransaction();
			TTitle title = (TTitle) dao.findById(TTitle.class, titleid);
			String hql = "from TOption where titleid = ?";
			Object[] para = { titleid };
			List<TOption> options = dao.select(hql, para);
			for (TOption tOption : options) {
				session.delete(tOption);
			}
			session.delete(title);
			tx.commit();
			session.close(); // 关闭连接
			return true;
		} catch (Exception e) {
			if (tx != null) tx.rollback();
			session.close(); // 关闭连接
			log.error("persistent.impl.TitleImpl类的deleteTitle(int titleid)方法调用错误：");
			log.error(LogUtil.getMsg(e));
			System.out.println("persistent.impl.TitleImpl类的deleteTitle(int titleid)方法调用错误：");
			e.printStackTrace();
		}
		return false;
	}

	/**
	 * 删除一个选项信息
	 * @param option 选项信息编号
	 * @return 成功返回true，失败返回false
	 */
	@Override
	public boolean deleteOption(String optionid) {		
		
		Session session = HibernateSessionFactory.getSession();
		Transaction tx = null;
		try {
			tx = session.beginTransaction();
			TOption option = (TOption) dao.findById(TOption.class, optionid);
			//TODO 2019-02-26 徐震霖修改
			TTitle title = (TTitle) dao.findById(TTitle.class, option.getTitleid());	
			//TODO 2019-02-26 徐震霖修改
			title.setOptionContent(title.getOptionContent().replace(option.getOptionContent() + Constant.STRING_SPLIT, ""));
			title.setOptionNumber(title.getOptionNumber() - 1);
			session.update(title);
			session.delete(option);
			tx.commit();
			session.close(); // 关闭连接
			return true;
		}
		catch (Exception e) {
			if (tx != null) tx.rollback();
			session.close(); // 关闭连接
			log.error("persistent.impl.TitleImpl类的deleteOption(String optionid)方法调用错误：");
			log.error(LogUtil.getMsg(e));
			System.out.println("persistent.impl.TitleImpl类的deleteOption(String optionid)方法调用错误：");
			e.printStackTrace();
		}		
		return false;
	}

	/**
	 * 根据ID获得一个题目信息
	 * @param titleid 题目信息ID
	 * @return 成功返回一个题目信息对象，失败返回null
	 */
	@Override
	public TTitle getTTitle(String titleid) {
		return (TTitle) dao.findById(TTitle.class, titleid);
	}

	/**
	 * 根据ID获得一个选项信息
	 * @param optionid 选项信息ID
	 * @return 成功返回一个选项信息对象，失败返回null
	 */
	@Override
	public TOption getTOption(String optionid) {
		return (TOption) dao.findById(TOption.class, optionid);
	}

	/**
	 * 根据条件获得题目信息列表
	 * @param strWhere 查询条件
	 * @return 成功返回一个题目信息对象列表，失败返回null
	 */
	@Override
	public List<VTitle> getTitles(String strWhere) {
		String hql = "from VTitle" + strWhere;
		return dao.select(hql);
	}

	/**
	 * 根据条件分页获得题目信息列表
	 * @param strWhere 查询条件
	 * @param currentPage 当前页
	 * @param pageSize 每页条数
	 * @return 成功返回一个题目信息对象列表，失败返回null
	 */
	@Override
	public List<VTitle> getTitlesByPage(String strWhere, int currentPage, int pageSize) {
		String hql = "from VTitle" + strWhere;
		return dao.selectByPage(hql, currentPage, pageSize);
	}

	/**
	 * 根据条件获得选项信息对象列表
	 * @param strWhere 查询条件
	 * @return 成功返回一个选项信息对象列表，失败返回null
	 */
	@Override
	public List<TOption> getOptions(String strWhere) {
		String hql = "from TOption" + strWhere;
		return dao.select(hql);
	}

	/**
	 * 批量导入题目信息
	 * @param titleBatchs 题目和选项信息对象列表
	 * @return 成功返回null，失败返回List<TitleBatch>的错误对象信息列表
	 */
	@Override
	public List<TitleBatch> batchImport(List<TitleBatch> titleBatchs) {
		Session session = HibernateSessionFactory.getSession();
		Transaction tx = null;
		tx = session.beginTransaction();
		GenerateUUID uuid = new GenerateUUID();
		List<TitleBatch> failList = new ArrayList<TitleBatch>();
		for (TitleBatch titleBatch : titleBatchs) {
			try {
				TTitle title = new TTitle();
				String titleid = uuid.getUUID();
				title.setTitleName(titleBatch.getTitleName());
				title.setTitleDescribe(titleBatch.getTitleDescribe());
				title.setTitleNumber(titleBatch.getTitleNumber());
				title.setTitleType(titleBatch.getTitleType());
				title.setOptionNumber(titleBatch.getOptionNumber());
				//TODO 2019-02-28 09:45 徐震霖修改开始
				title.setScaleTitleTypeid(titleBatch.getDimensionid());
				//TODO 2019-02-28 09:45 徐震霖修改结束
				title.setOptionContent(titleBatch.getOptionContent());
				title.setTitleid(titleid);
				session.save(title);
				String[] aoptions = titleBatch.getOptionContent().split(Constant.STRING_SPLIT);
				for(int i = 0; i < aoptions.length; i++){
					String optionid = uuid.getUUID();
					TOption option = new TOption();
					option.setOptionContent(aoptions[i]);
					option.setOptionid(optionid);
					option.setOptionNumber(i + 1);
					option.setOptionScore(titleBatch.getOptionScore());
					option.setTitleid(titleid);
					session.save(option);
				}
			} catch (Exception e) {
				failList.add(titleBatch);
				log.error("persistent.impl.TitleImpl类的batchImport(List<TitleBatch> titleBatchs)方法调用错误：");
				log.error(LogUtil.getMsg(e));
				System.out.println("persistent.impl.TitleImpl类的batchImport(List<TitleBatch> titleBatchs)方法调用错误：");
				e.printStackTrace();
			}			
		}
		if(tx != null && failList.size() == 0){
			tx.commit();
			session.close(); //关闭连接
			return null;
		}
		if(tx != null && failList.size() > 0){
			tx.rollback();
			session.close(); //关闭连接
			return failList;
		}
		return null;
	}

	/**
	 * 添加一个题目信息（添加题目信息的同时要添加选项信息）
	 * @param title 题目信息对象
	 * @param dimensionid 题目所属维度
	 * @return 成功返回true，失败返回false
	 */
	@Override
	public boolean addTitle(TTitle title, int dimensionid) {
		//TODO 2019-03-05 18:06 徐震霖修改开始
		Session session = HibernateSessionFactory.getSession();
		Transaction tx = null;
		Expression exp = new Expression();
		
		try {
			tx = session.beginTransaction();
						
			exp.andEqu("dimensionid", dimensionid, Integer.class);
			exp.orderByAsc("optionNumber");
			String hql = "from TDimensionOption " + exp.toString();
			List<TDimensionOption> options = dao.select(hql);
			
			if (options != null && options.size() > 0) {
				String optionContent = "";
				for (TDimensionOption option : options){
					optionContent += option.getOptionContent() + Constant.STRING_SPLIT;
				}
				
				GenerateUUID uuid = new GenerateUUID();
				String titleid = uuid.getUUID();
				title.setTitleid(titleid);
				title.setOptionNumber(options.size());
				title.setOptionContent(optionContent);
				session.save(title);
				for (TDimensionOption tDimensionOption : options) {
					TOption option = new TOption();
					option.setOptionContent(tDimensionOption.getOptionContent());
					option.setOptionid(uuid.getUUID());
					option.setOptionNumber(tDimensionOption.getOptionNumber());
					option.setOptionScore(tDimensionOption.getOptionScore());
					option.setTitleid(titleid);
					session.save(option);
				}
				tx.commit();
				session.close(); // 关闭连接
				return true;
			}
			else {
				return false;
			}	
		}
		catch (Exception e) {
			if (tx != null) tx.rollback();
			session.close(); // 关闭连接
			log.error("persistent.impl.TitleImpl类的addTitle(TTitle title, int dimensionid)方法调用错误：");
			log.error(LogUtil.getMsg(e));
			System.out.println("persistent.impl.TitleImpl类的addTitle(TTitle title, int dimensionid)方法调用错误：");
			e.printStackTrace();
		}
		//TODO 2019-03-05 18:06 徐震霖修改结束
		return false;
	}

	/**
	 * 开启或关闭一个题目的反选（选项分值反过来）
	 * @param titleid 题目编号
	 * @param isReverse 是否开启反选（0为不开启反选，1为开启反选）
	 * @return 成功返回true，失败返回false
	 */
	@Override
	public boolean enableOrDisEnableReverse(String titleid, int isReverse) {
		
		Session session = HibernateSessionFactory.getSession();
		Transaction tx = null;
		Expression exp = new Expression();
		
		exp.andEqu("titleid", titleid, String.class);
		exp.orderByAsc("optionScore");
		String hql = "from TOption " + exp.toString();
		List<TOption> options = dao.select(hql);
		try {
			tx = session.beginTransaction();
			if (options.size() > 2) {
				for(int i = 0; i < options.size(); i++){
					TOption option = options.get(i);
					option.setOptionScore(options.size() - i);
					session.update(option);
				}
			}
			else {
				for(int i = 0; i < options.size(); i++){
					TOption option = options.get(i);
					if (option.getOptionScore() == 1) {
						option.setOptionScore(0);
					}
					else {
						option.setOptionScore(1);
					}
					session.update(option);
				}
			}
			TTitle title = (TTitle) dao.findById(TTitle.class, titleid);
			title.setIsReverse(isReverse);
			session.update(title);
			tx.commit();
			session.close(); // 关闭连接
			return true;
		}
		catch (Exception e) {
			if (tx != null) tx.rollback();
			session.close(); // 关闭连接
			log.error("persistent.impl.TitleImpl类的enableOrDisEnableReverse(String titleid, int isReverse)方法调用错误：");
			log.error(LogUtil.getMsg(e));
			System.out.println("persistent.impl.TitleImpl类的enableOrDisEnableReverse(String titleid, int isReverse)方法调用错误：");
			e.printStackTrace();
		}	
		return false;
	}

}
